package com.example.demo.demotwo.stream;

import com.example.demo.model.Person;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

//stream 中间操作api，因为必须有最终操作所有测试时候有添加
/*
 * 中间操作：0~n步
 * （1）filter(Predicate p)：过滤
 * （2）distinct()：去重
 * （3）limit(long maxSize)：限制几个
 * （4）skip(long n)：跳过几个
 * （5）sorted()：排序  		用元素的自然排序
 *    sorted(Comparator com)排序  		用定制排序
 * （6）peek(Consumer action)：对流中的数据进行Consumer指定的操作，但是不影响元素的个数
 * （7）map(Function f)
 * （8）mapToDouble(ToDoubleFunction f)
 * （9）flatMap(Function f)
 *
 * 为了验证结果，必须有终结操作，才能看到结果
 * 终结操作：void forEach(Consumer c)
 * 		  long count()：统计流中的元素的个数
 * 		T reduce(DoubleBinaryOperator op)
 * 一:
 *Consumer 消费型接口 消费对象
 *void accept(T t);
 * 二:
 *Supplier 供给型接口 生成对象
 *T get();
 * 三:
 *Function<R,T> 函数型接口 指定特定功能
 *R apply(T t);
 * 四:
 *Predicate 断言型接口 进行条件判断
 *boolean test(T t);
 *
 *
 *
 * /
 */
public class Middle {

   //1.filter(Predicate p)：过滤
   @Test
   public void filterTest(){
      List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
      List<Integer> collect = numList.stream()
              .filter(num -> num % 2 == 0)//取偶数
              .collect(Collectors.toList());
      System.out.println("filter测试:");
      collect.forEach(num -> System.out.println(num));
   }

   //2.distinct()：去重
   @Test
   public void distinctTest(){
      List<Integer> numList = Arrays.asList(1,1,2, 2, 3, 4, 5, 6, 7, 8, 9);
      List<Integer> collect = numList.stream()
              .distinct() //去重
              .collect(Collectors.toList());
      System.out.println("distinct测试:");
      collect.forEach(num -> System.out.println(num));
   }

   //3.limit(long maxSize)：限制几个
   @Test
   public void limitTest(){
      List<Integer> numList = Arrays.asList(1,1,2, 2, 3, 4, 5, 6, 7, 8, 9);
      List<Integer> collect = numList.stream()
              .limit(4)
              .collect(Collectors.toList());
      System.out.println("limit测试:");
      collect.forEach(n-> System.out.println(n));
   }
   //4.skip(long n)：跳过几个
   @Test
   public void skipTest(){
      List<Integer> numList = Arrays.asList(1,1,2, 2, 3, 4, 5, 6, 7, 8, 9);
      List<Integer> collect = numList.stream()
              .skip(2)
              .collect(Collectors.toList());
      System.out.println("skip测试:");
      collect.forEach(n-> System.out.println(n));
   }

   //5.sorted()：排序  		用元素的自然排序
   @Test
   public void sortedTest(){
      List<Integer> numList = Arrays.asList(16,1,8, 2, 5, 4, 2, 9, 17, 118, 19);
      List<Integer> collect = numList.stream()
              .sorted()
              .collect(Collectors.toList());
      System.out.println("sorted测试:");
      collect.forEach(n-> System.out.println(n));
   }
   //6.sorted(Comparator com)排序  		用定制排序
   @Test
   public void sortedTest2(){
      List<Integer> numList = Arrays.asList(16,1,8, 2, 5, 4, 2, 9, 17, 118, 19);
      List<Integer> collect = numList.stream()
              .sorted((n1, n2) -> -Integer.compare(n1, n2)) //从大到小排序
              .collect(Collectors.toList());
      System.out.println("sorted comparator测试:");
      collect.forEach(n-> System.out.println(n));

   }

   //7.peek(Consumer action)：对流中的数据进行Consumer指定的操作，但是不影响元素的个数
   @Test
   public void peekTest(){
      List<Integer> numList = Arrays.asList(16,1,8, 2, 5, 4, 2, 9, 17, 118, 19);
      List<Integer> collect = numList.stream()
              .peek(n -> System.out.println("peek测试:" + n))//打印
              .collect(Collectors.toList());
   }
   //8.map(Function f) ：对值进行操作，然后进行返回
   @Test
   public void mapTest(){
      List<Integer> numList = Arrays.asList(16,1,8, 2, 5, 4, 2, 9, 17, 118, 19);
      List<String> collect = numList.stream()
              .map(n -> "数字:" + n)
              .collect(Collectors.toList());
      System.out.println("map测试:");
      collect.forEach(n-> System.out.println(n));
   }

   //9.mapToDouble(ToDoubleFunction f)
   //跟map一样，只是多了个转换，转成map进行操作
   @Test
   public void mapToDouble(){
       Person zs = Person.builder().name("张三").age("10").money("20.01").build();
       Person ls = Person.builder().name("李四").age("5").money("15.02").build();
       Person ww = Person.builder().name("王五").age("7").money("32.03").build();
       List<Person> people = Arrays.asList(zs, ls, ww);
       double sum = people.stream()
               .mapToDouble(p -> Double.valueOf(p.getMoney()))
               .sum();
       System.out.println("mapToDouble测试:" + sum);
   }

   //10.flatMap(Function f)
   @Test
   public void flatMapTest(){

   }










    
    
    
    
}
